// 除法函数，用来得到精确的除法结果
export function accDiv(arg1, arg2) {
  // console.log(arg1, arg2)
  let t1 = 0
  let t2 = 0
  let r1
  let r2
  try {
    t1 = arg1.toString().split('.')[1].length
  } catch (e) {}
  try {
    t2 = arg2.toString().split('.')[1].length
  } catch (e) {}
  if (Math) {
    r1 = Number(arg1.toString().replace('.', ''))
    r2 = Number(arg2.toString().replace('.', ''))
    return (r1 / r2) * Math.pow(10, t2 - t1)
  }
}

// 乘法函数，用来得到精确的乘法结果
export function accMul(arg1, arg2) {
  // console.log(arg1, arg2)
  let m = 0
  const s1 = arg1.toString()
  const s2 = arg2.toString()
  try {
    m += s1.split('.')[1].length
  } catch (e) {}
  try {
    m += s2.split('.')[1].length
  } catch (e) {}
  return (Number(s1.replace('.', '')) * Number(s2.replace('.', ''))) / Math.pow(10, m)
}

// 加法函数，用来得到精确的加法结果
export function accAdd(arg1, arg2) {
  var r1, r2, m
  try {
    r1 = arg1.toString().split('.')[1].length
  } catch (e) {
    r1 = 0
  }
  try {
    r2 = arg2.toString().split('.')[1].length
  } catch (e) {
    r2 = 0
  }
  m = Math.pow(10, Math.max(r1, r2))
  return (arg1 * m + arg2 * m) / m
}
// 减法函数，用来得到精确的减法结果
export function accSub(arg1, arg2) {
  var r1, r2, m, n
  try {
    r1 = arg1.toString().split('.')[1].length
  } catch (e) {
    r1 = 0
  }
  try {
    r2 = arg2.toString().split('.')[1].length
  } catch (e) {
    r2 = 0
  }
  m = Math.pow(10, Math.max(r1, r2))
  // last modify by deeka
  // 动态控制精度长度
  n = r1 >= r2 ? r1 : r2
  return ((arg1 * m - arg2 * m) / m).toFixed(n)
}

// 毫秒转换为分钟
export function convertMinute(endTime, startTime) {
  const m = new Date(endTime).getTime() - new Date(startTime).getTime()
  return accDiv(m, 60000)
}

// 检测结果概览-type=1是录像状况检测结果/type=0录像巡检历史检测结果
export function jsonstrF(_this, data, width, type) {
  if (!data) {
    return
  }
  // 分钟 1440 一天
  const minute = 1440
  // 每一分钟宽度
  const itemW = accDiv(width, minute)
  // console.log(data.length)
  for (let i = 0; i < data.length; i++) {
    // const time = data[i].datesign
    // console.log(data)
    if ((!data[i].jsonstr && type === 1) || (!data[i].timestamp && type === 0)) {
      continue
    }
    if ((data[i].datesign === '' && type === 1) || (data[i].dateSign === '' && type === 0)) {
      continue
    }
    var jsonObj
    var time
    // 1 录像状况详情  2 录像巡检历史
    switch (type) {
      case 1:
        time = data[i].datesign
        // console.log('执行前', JSON.parse(data[i].jsonstr))
        var list1 = jcArr(JSON.parse(data[i].jsonstr))
        jsonObj = getListJc(list1, time)
        break
      default:
        time = data[i].dateSign
        var list2 = jcArr(JSON.parse(data[i].timestamp))
        jsonObj = getListJc(list2, time)
        break
    }
    for (let j = 0; j < jsonObj.length; j++) {
      // 每个li的时间 和宽度
      const liMinute = convertMinute(jsonObj[j].endTime, jsonObj[j].startTime)
      let liWidth = accMul(liMinute, itemW)

      // 偏移值 left (转换为分钟)
      const liLeftMinute = convertMinute(jsonObj[j].startTime, time + ' 00:00:00')
      let liLeft = accMul(liLeftMinute, itemW)

      if (liMinute < 0) {
        liWidth = accMul(convertMinute(jsonObj[j].endTime, time + ' 00:00:00'), itemW)
        liLeft = 0
      }
      _this.tableData[i].jcjgList.push({
        width: liWidth.toFixed(1) < 2 ? '1px' : liWidth.toFixed(1) + 'px',
        left: liLeft.toFixed(1) + 'px'
      })
    }
  }
}
// 检测数组数据
export function jcArr(list) {
  // 判断数组是否满足b1和b2条件
  list.forEach((item, index) => {
    if (index > 0) {
      const b1 = list[index].startTime < list[index - 1].endTime // 判断当前开始时间<上一条的结束时间
      const b2 = list[index].startTime === list[index - 1].startTime && list[index].endTime > list[index - 1].endTime // 判断本次的开始时间=上一次的开始时间 但是本次的结束时间>上次的结束时间
      if (b2) {
        // 删除上一项
        // console.log('本次的开始时间=上一次的开始时间 但是本次的结束时间>上次的结束时间', item)
        list.splice(index - 1, 1)
      } else if (b1) {
        // 本次的结束时间>上次的结束时间
        // console.log(list[index].startTime, '-----当前开始时间<上一次结束时间-----', list[index - 1].endTime)
        // 删除当前项
        list.splice(index, 1)
      }
    }
  })
  var jsonstr = JSON.stringify(list)
  // console.log('删除后：', list)
  // console.log('删除后：', jsonstr)
  return jsonstr
}

// 获取时间  value为负数取向前  整数取向后
export function fun_date(aa) {
  const date1 = new Date()
  const currentMonth = date1.getMonth() + 1 > 9 ? date1.getMonth() + 1 : '0' + (date1.getMonth() + 1)
  const currentDay = date1.getDate() > 9 ? date1.getDate() : '0' + date1.getDate()
  const currentTime = date1.getFullYear() + '-' + currentMonth + '-' + currentDay // time1表示当前时间
  const date2 = new Date(date1)
  date2.setDate(date1.getDate() + aa)
  const month = date2.getMonth() + 1 > 9 ? date2.getMonth() + 1 : '0' + (date2.getMonth() + 1)
  const day = date2.getDate() > 9 ? date2.getDate() : '0' + date2.getDate()
  const otherTime = date2.getFullYear() + '-' + month + '-' + day
  const h = date1.getHours() > 9 ? date1.getHours() : `0${date1.getHours()}` // 获取当前小时数(0-23)
  const m = date1.getMinutes() > 9 ? date1.getMinutes() : `0${date1.getMinutes()}` // 获取当前分钟数(0-59)
  const s = date1.getSeconds() > 9 ? date1.getSeconds() : `0${date1.getSeconds()}` // 获取当前秒数(0-59)
  const current = `${currentTime} ${h}:${m}:${s}`
  const date3 = new Date(date1.getTime() - 1 * 60 * 60 * 1000)
  const h3 = date3.getHours() > 9 ? date3.getHours() : `0${date3.getHours()}` // 获取当前小时数(0-23)
  const m3 = date3.getMinutes() > 9 ? date3.getMinutes() : `0${date3.getMinutes()}` // 获取当前分钟数(0-59)
  const s3 = date3.getSeconds() > 9 ? date3.getSeconds() : `0${date3.getSeconds()}` // 获取当前秒数(0-59)
  const frontOneHour = `${currentTime} ${h3}:${m3}:${s3}`
  const time = {
    currentTime: currentTime,
    otherTime: otherTime,
    current: current,
    frontOneHour: frontOneHour,
    date1: new Date(date1).getTime()
  }
  return time
}
// 获取刚刚/几分钟钱/几小时钱/几天前
export function timeago(now, dateTimeStamp) {
  var minute = 1000 * 60 // 把分，时，天，周，半个月，一个月用毫秒表示
  var hour = minute * 60
  var day = hour * 24
  var week = day * 7
  var result = ''
  // var halfamonth = day * 15
  var month = day * 30
  // var now = new Date().getTime() // 获取当前时间毫秒
  var diffValue = accSub(now, dateTimeStamp) // 时间差
  // console.log('---now', now)
  // console.log('---dateTimeStamp', dateTimeStamp)
  // console.log('---diffValue', diffValue)
  if (diffValue < 0) {
    return
  }
  var minC = diffValue / minute // 计算时间差的分，时，天，周，月
  var hourC = diffValue / hour
  var dayC = diffValue / day
  var weekC = diffValue / week
  var monthC = diffValue / month
  if (monthC >= 1 && monthC <= 3) {
    result = ' ' + parseInt(monthC) + '月前'
  } else if (weekC >= 1 && weekC <= 3) {
    result = ' ' + parseInt(weekC) + '周前'
  } else if (dayC >= 1 && dayC <= 6) {
    result = ' ' + parseInt(dayC) + '天前'
  } else if (hourC >= 1 && hourC <= 23) {
    result = ' ' + parseInt(hourC) + '小时前'
  } else if (minC >= 1 && minC <= 59) {
    result = ' ' + parseInt(minC) + '分钟前'
  } else if (diffValue >= 0 && diffValue <= minute) {
    result = '刚刚'
  } else {
    var datetime = new Date()
    datetime.setTime(dateTimeStamp)
    var Nyear = datetime.getFullYear()
    var Nmonth = datetime.getMonth() + 1 < 10 ? '0' + (datetime.getMonth() + 1) : datetime.getMonth() + 1
    var Ndate = datetime.getDate() < 10 ? '0' + datetime.getDate() : datetime.getDate()
    // var Nhour = datetime.getHours() < 10 ? '0' + datetime.getHours() : datetime.getHours()
    // var Nminute = datetime.getMinutes() < 10 ? '0' + datetime.getMinutes() : datetime.getMinutes()
    // var Nsecond = datetime.getSeconds() < 10 ? '0' + datetime.getSeconds() : datetime.getSeconds()
    result = Nyear + '-' + Nmonth + '-' + Ndate
  }
  return result
}
// 时间戳转日期格式
export function formatDateTime3(time, format) {
  var t = new Date(time)
  var tf = function(i) {
    return (i < 10 ? '0' : '') + i
  }
  return format.replace(/yyyy|MM|dd|HH|mm|ss/g, function(a) {
    switch (a) {
      case 'yyyy':
        return tf(t.getFullYear())
      case 'MM':
        return tf(t.getMonth() + 1)
      case 'mm':
        return tf(t.getMinutes())
      case 'dd':
        return tf(t.getDate())
      case 'HH':
        return tf(t.getHours())
      case 'ss':
        return tf(t.getSeconds())
    }
  })
}

// 列表检测结果数值转换
export function getListJc(jsonstr, time) {
  const newArr = []
  if (!jsonstr) {
    return
  }
  const list = JSON.parse(jsonstr)
  for (let i = 0; i < list.length; i++) {
    if (i >= list.length - 1) {
      if (i === list.length - 1) {
        var lastTime = new Date(list[i].endTime).getTime()
        // 明天的时间
        var day3 = new Date(time)
        day3.setTime(day3.getTime() + 24 * 60 * 60 * 1000)
        var s3 = day3.getFullYear() + '-' + (day3.getMonth() + 1) + '-' + day3.getDate()
        var tomorrow = new Date(`${s3} 00:00:00`).getTime()
        if (lastTime < tomorrow) {
          newArr.push({
            startTime: list[i].endTime,
            endTime: `${s3} 00:00:00`
          })
        }
      }
      continue
    }
    if (i === 0) {
      var firstTime = new Date(list[i].startTime).getTime() // 最开始时间
      var dateSignTime = new Date(`${time} 00:00:00`).getTime() // 刻度渲染时间
      if (firstTime > dateSignTime) {
        // console.log(firstTime, dateSignTime)
        newArr.push({
          startTime: `${time} 00:00:00`,
          endTime: list[i].startTime
        })
      }
    }
    var endTime = new Date(list[i].endTime).getTime() // 结束时间
    var startTime = new Date(list[i + 1].startTime).getTime() // 下一个开始时间
    if (startTime !== endTime) {
      newArr.push({
        startTime: list[i].endTime,
        endTime: list[i + 1].startTime
      })
    }
  }
  return newArr
}

// 检测结果重组数组
export function getJc(jsonstr) {
  const newArr = []
  if (!jsonstr) {
    return
  }
  const list = JSON.parse(jsonstr)
  // newArr = [list[0]]
  for (let i = 0; i < list.length; i++) {
    if (i >= list.length - 1) {
      continue
    }
    var endTime = new Date(list[i].endTime).getTime() // 结束时间
    var startTime = new Date(list[i + 1].startTime).getTime() // 下一个开始时间
    if (startTime !== endTime) {
      // console.log(i, list[i], list[i + 1])
      newArr.push(list[i])
      // newArr.push({
      //   startTime: list[i].endTime,
      //   endTime: list[i + 1].startTime
      // })
      newArr.push(list[i + 1])
    }
    // if (list[list.length - 1] === i) {
    // }
  }
  // newArr.push(list[list.length - 1])
  // const a = []
  // for (let i = 0; i < newArr.length; i++) {
  //   // var satart = ''
  //   // var end = ''
  //   if (i % 2 !== 0) {
  //     // 奇数
  //     if (i >= newArr.length - 1) {
  //       continue
  //     }
  //     console.log(newArr[i].endTime, newArr[i + 1].startTime)
  //     a.push({
  //       startTime: newArr[i].endTime,
  //       endTime: newArr[i + 1].startTime
  //     })
  //   }
  //   // else {
  //   //   if (i > 0) {
  //   //     end = newArr[i].startTime
  //   //   }
  //   // }
  //   // a.push({
  //   //   startTime: satart,
  //   //   endTime: end
  //   // })
  // }
  // console.log(newArr)
  // console.log(a)
  return newArr
}

// export function initTImeList(timecellList, flag) {
//   console.log(timecellList, flag)
//   if (!timecellList.jsonstr) {
//     this.timecell = []
//     return
//   }
//   if (timecellList.datesign === '') {
//     this.timecell = []
//     return
//   }
//   this.timelineLoad = true
//   const list = JSON.parse(timecellList.jsonstr)
//   // this.start_timestamp = new Date('2020-07-02 00:00:00').getTime() //  渲染刻度开始时间
//   this.start_timestamp = new Date(`${timecellList.datesign} 00:00:00`).getTime() //  渲染刻度开始时间
//   const arr = []
//   let start = ''
//   const end = ''
//   let lastEnd = ''

//   list.forEach((item, index) => {
//     if (index === 0) {
//       // start= 第一次的开始时间
//       // lastEnd = item.endTime 结束日期 缓存
//       start = item.startTime // 第一次的开始时间
//       lastEnd = item.endTime // 结束日期 缓存
//     }
//     if (index !== 0) {
//       // 不是第一次时
//       if (item.startTime === lastEnd) {
//       } else {
//         // 上次结束日期不等于 这一次的开始日期

//         // end =  endTime 等于当前下标结束日期 进行push

//         arr.push({
//           // 渲染有录像文件的段
//           beginTime: new Date(start).getTime() + (new Date(end).getTime() - new Date(start).getTime()),
//           endTime: new Date(end).getTime() + (new Date(end).getTime() - new Date(start).getTime()),
//           style: {
//             background: canvasColors[1]
//           }
//         })
//         // lastEnd 上一次的结束时间
//         arr.push({
//           // 将上一次的结束日期作为开始日期、当前下标的开始日期作为结束日期，渲染丢失段
//           beginTime: new Date(lastEnd).getTime() + (new Date(item.startTime).getTime() - new Date(lastEnd).getTime()),
//           endTime: new Date(item.startTime).getTime() + (new Date(item.startTime).getTime() - new Date(lastEnd).getTime()),
//           style: {
//             background: canvasColors[0]
//           }
//         })

//         // arr.push({
//         //   beginTime: new Date(item.startTime).getTime() + (new Date(item.endTime).getTime() - new Date(item.startTime).getTime()),
//         //   endTime: new Date(item.endTime).getTime() + (new Date(item.endTime).getTime() - new Date(item.startTime).getTime()),
//         //   style: {
//         //     background: canvasColors[1],
//         //   },
//         // })
//       }
//     }
//     //  else
//     // if(){// 判断最后一次

//     // }
//   })
//   this.timecell = arr
// }
